//通用方法

class ComFun {
    static BaseCall(...params: any[]) {
        try {
            if (KBEngine.app && KBEngine.app.player()) {
                KBEngine.app.player().baseCallEx(params);
            }
        } catch(e) {
		}
    }

    //范围内获取整数随机数
    //范围内获取整数随机数,均为闭区间
    static GetRandomInt(min:number, max:number) : number {  
        var Range = max - min;  
        var Rand = Math.random();  
        return (min + Math.round(Rand * Range));  
    }

    //获取数组中有指定数据的数据索引
    static GetArrayValueIndex(array:any, keyName:string, value:any) : number {
        for (let i = 0; i < array.length; i++) {
            let curData = array[i];
            if (value == curData[keyName]) {
                return i;
            }
        }
        return null;
    }

    //获取数组中有指定数据的值
    static GetArrayValue(array:any, keyName:string, value:any) : any {
        let e = null;
        array.forEach(element => {
            if(value == element[keyName]) return e=element;
        });
        return e;
    }

    static EncodeUtf8(text:string) {
        const code = encodeURIComponent(text);
        const bytes = [];
        for (var i = 0; i < code.length; i++) {
            const c = code.charAt(i);
            if (c === '%') {
                const hex = code.charAt(i + 1) + code.charAt(i + 2);
                const hexVal = parseInt(hex, 16);
                bytes.push(hexVal);
                i += 2;
            } else bytes.push(c.charCodeAt(0));
        }
        return bytes;
    }

    static Str2Utf8(str) : string {
        return encodeURI(str).replace(/%/gm, "\\x");
    }

    //从js对象创建一个python可以解析为字典的字符串
    static CreateDictString(dic:any) {
        let dictString = "";
        let len = 0;
        for(let prop in dic) {
            len++;
        }

        if(len > 0) {
            let index = 0;
            dictString = "{"
            for(let prop in dic) {
                dictString += "'" + prop + "'";
                dictString += ":";
                dictString += "'" + dic[prop] + "'";
                if(index == len-1) {
                    dictString += "}";
                }else {
                    dictString += ",";
                }
                index++;
            }
        }

        return ComFun.EncodeUtf8(dictString);
     }

     //格式化Date格式的时间,默认yyyy-MM-dd hh:mm:ss
     static formatDate(date : Date, fmt : string = "yyyy-MM-dd hh:mm:ss") : string{
         let o = {   
            "M+" : date.getMonth()+1,                 //月份   
            "d+" : date.getDate(),                    //日   
            "h+" : date.getHours(),                   //小时   
            "m+" : date.getMinutes(),                 //分   
            "s+" : date.getSeconds(),                 //秒   
            "q+" : Math.floor((date.getMonth()+3)/3), //季度   
            "S"  : date.getMilliseconds()             //毫秒   
        };
        if(/(y+)/.test(fmt)) fmt=fmt.replace(RegExp.$1, (date.getFullYear()+"").substr(4 - RegExp.$1.length)); 
        for(var k in o)   
            if(new RegExp("("+ k +")").test(fmt))   
                fmt = fmt.replace(RegExp.$1, (RegExp.$1.length==1) ? (o[k]) : (("00"+ o[k]).substr((""+ o[k]).length)));   
        return fmt;
     }

     //格式化毫秒值的时间,默认yyyy-MM-dd hh:mm:ss
     static formatTime(time : number, fmt : string = "yyyy-MM-dd hh:mm:ss") : string{
         return ComFun.formatDate(new Date(time), fmt);
     }

     /**
     * <p>格式化定时,最大单位"日",最小单位"毫秒"。</p>
     * @param fmt		时间格式,如d日hh小时mm分钟ss秒SS毫秒。
     * @param time	    时间毫秒单位,1000为1秒。
     * @param emptyDate 是否保留空时间段,默认为true保留
     * @return 格式化后的显示时间的字符串。
     */
     static formatTiming(time : number, fmt : string = "dd日hh小时mm分钟ss秒", emptyDate : boolean = true) : string{
        let o = [  
            {"reg":"d+", "per":86400000},  //日   
            {"reg":"h+", "per":3600000},   //小时   
            {"reg":"m+", "per":60000},     //分   
            {"reg":"s+", "per":1000},      //秒   
            {"reg":"S+", "per":1}          //毫秒   
        ];
        for(let i = 0;i<o.length;i++){
            //let reg = new RegExp("("+ o[i]["reg"] +")").exec(fmt);
            let reg = fmt.match(new RegExp(o[i]["reg"]));
            let t = Math.floor(time / o[i]["per"]);
            let tStr = t + "";
            let temp = "";
            if(reg){
                if(t > 0 || emptyDate){
                    for(let i=0; i<reg[0].length; i++) temp = temp + "0";
                    fmt = fmt.replace(reg[0], (reg[0].length==1) ? (tStr) : ((temp+ tStr).substr(tStr.length<reg[0].length?tStr.length:reg[0].length)));
                    time = time % o[i]["per"];
                }else{
                    if(i == o.length-1){
                        fmt = fmt.replace(fmt.substring(reg.index),"");
                    }else{
                        let reg1;
                        for(let j = i+1; j<o.length; j++){
                            reg1 = fmt.match(new RegExp(o[j]["reg"]));
                            if(reg1) break;
                        }
                        if(reg1){
                            fmt = fmt.replace(fmt.substring(reg.index,reg1.index),"");
                        }else{
                            fmt = fmt.replace(fmt.substring(reg.index),"");
                        }
                    }
                }
            }
        }
        return fmt;
     }

     /**
      * <p>将源容器内坐标值转换成目标容器内坐标值。</p>
      * @param source		源容器
      * @param target	    目标容器
      * @param srcPoint        源容器内坐标值
      * @return 目标容器内坐标值
      */
      static pointChange(source : laya.display.Sprite, target : laya.display.Sprite, srcPoint : laya.maths.Point):laya.maths.Point{
            let point = source.localToGlobal(srcPoint);
            return target.globalToLocal(point);
      }

      /**
       * 格式化输出文字
       * formatText("这是{0}参数",["第一个"]),返回 "这是第一个参数"
       * formatText("这是{param}参数",{param:"第一个"}),返回 "这是第一个参数"
       * @param source		源数据,里面需要转化的参数使用{},例如{0}或{name}
       * @param params      需要替换的内容,可以是数组,对象或字符串,可以是","分割的字符串
       * @return 格式化后的文字.
       */
    static formatText(source : string, params : any) : string{
        if(params == null){
            return "";
        }
        if(params.constructor == Array){
            var reg = /{(\d+)}/gm;
            return source.replace(reg,function(match,name){
                return params[~~name];
            });
        }
        if(params.constructor == Object){
            let reg = /{([^{}]+)}/gm;
            return source.replace(reg,function(match,name){
                return params[name];
            });
        }
        if(params.constructor == String){
            let param = params.split(",");
            let reg = /{([^{}]+)}/gm;
            return source.replace(reg,function(match,name){
                return param[name];
            });
        }
        return "";
    }
}